Funksione te koleksioneve Array

Koleksionet Array jane koleksione te cilat na sherbejne per mbajtjen e te dhenave te shumta ne forme te menaxhueshme. Permendem me siper qe kemi disa lloje array-sh, te indeksuar, associative dhe multidimensional. Per manipulimin dhe procesimin e ketyre koleksioneve, PHP-ja permban shume funksione te brendshme te cilat nuk eshte e nevojshme te importohen nga jashte, por vijne sebashku me te. Me poshte do te listojme dhe shpjegojme nje pjese te funksioneve kryesore te koleksioneve array te cilat do te na duhen per perdorim te vazhdueshem.

`array_merge`

array_merge($array [, ...$array...])

Si input mund te pranoje nje ose me shume koleksione array.

Ne rast se ne hyrje i kalojme vetem nje array te indeksuar, ky funksion riindekson (krijon indekset nga fillimi) kete array dhe e kthen ate. Riindeksim do te thote vendosje e indekseve nga e para. P.sh. supozojme qe nje array $arr ka indekset jane [0], [2], [3] per arsyje se elementi i dyte mund te jete bere unset ose prej ndonje arsyeje tjeter. Ne rast se mbi array-n e mesiperm aplikojme funksionin array_merge($arr) do te na kthehet nje array i ri me indekse te rivendosur [0], [1], [2] sipas radhes.

Ne rast se ne hyrje i kalojme dy ose me shume array, do te na kthehet nje array i ri me vlera te kombinuara te te gjithe koleksioneve array te vendosura ne hyrje. Sa i perket indekseve numerike te array-ve, ata do te rivendosen ne menyre te tille qe asnje element i array-ve te mos humbase. Sa i perket celsave associative, ne rast se keto array kane celesa te njejte, disa vlera do te humbasin pasi do te ruhen vetem vlerat e elementeve te array-t te fundit te vendosur ne hyrje.

Shembull: Rasti kur vendosim nje array ne hyrje:

$array = array ( 3 => 'nje', 0 => 'dy', 2 => 'tre' );

$merged_array = array_merge($array);

print_r($merged_array);

Pas printimit te $merged_array, rezultati ne dalje do te jete:

Array
(
  [0] => nje
  [1] => dy
  [2] => tre
)

Rasti kur vendosim me shume se nje array ne hyrje:

$array1 = array ( 'zero', 'nje', 'emri' => 'Arber' );
$array2 = array ( 'tre', 'emri' => 'Joni', 'profesioni' => 'mesues' );

$merged_array = array_merge($array1, $array2);
print_r( $merged_array );

Rezultati:

Array
(
  [0] => zero
  [1] => nje
  [emri] => Joni
  [2] => tre
  [profesioni] => mesues
)

Dy koleksionet array ne hyrje kishin nga 3 elemente, te dyja sebashku 6 elemente, por pas printimit shohim qe array i formuar permban 5 elemente. Arsyeja pse kjo ka ndodhur eshte per shkak te celesit associative me vlere emri i cili gjendet ne te dyja array-t e aplikuara. Kjo perplasje ben qe te ruhet vetem celesi i array-t te futur se fundmi ne hyrje, ci cili eshte $array2. Ndaj edhe vlera e celesit emri eshte Joni pasi kjo vlere gjendej ne array-n e dyte.

`$array1 + $array2`

Ne rast se perdorim simbolin + per te bashkuar dy array atehere:

Array i pare ka me shume prioritet
Ne rast se gjenden celesa associative te njejte ndermjet ketyre koleksioneve, do te ruhen vetem celesat e array-t te pare
Ne rast se gjenden indekse te njejta ndermjet ketyre koleksioneve, do te ruhen vetem celesat e array-t te pare, p.sh. elementi me indeks [0] i array-t te pare e mbishkruan elementin me indeks [0] te array-t te dyte.

Shembull:

$array = array ( 'zero', 'emri' => 'Arber', 'profesioni' => 'inxhinier' );
$array2 = array ( 'tre', 'profesioni' => 'mesues', 'mosha' => 32 );
print_r( $array + $array2 );

Rezultati:

Array
(
  [0] => zero
  [emri] => Arber
  [profesioni] => mesues
  [mosha] => 32
)

Elementi [0] me vlere tre i array-t te dyte nuk eshte printuar pasi ai mposhtet nga elementi [0] i array-t te pare me vlere zero. Elementi me celes profesioni i array-t te dyte nuk eshte printuar pasi ai mposhtet nga elementi me celes profesioni i array-t te pare. Elementi me celes mosha i array-t te dyte eshte printuar pasi ai eshte unik, nuk gjendet ne array-n e pare nje celes i tille.

`count`

count($array [, mode])

mode – [opsional] $integer default: 0,

Ky funksion llogarit numrin e elementeve te koleksionit array ne hyrje dhe e kthen ate. Ne rast se parametri opsional mode nuk vendoset, vlera e tij mbetet default 0, e cila nuk i numeron koleksionet array te brendshme (ne rastin e array-ve multidimensional), por numeron vetem elementet e array-t prind. Ne rast se parametri mode vendoset 1, atehere numerohen edhe elementet e array-ve te brendshme ne rast se ka.

Shembull:

$array = array ('zero',
                'emrat' => array ( 'Arber', 'Endri' ),
                'moshat' => array ( 26, 25 ) );
echo count($array);

Rezultati: 3

Ne rast se mode vendoset 1:

echo count($array, 1);

Rezultati ne daljet do te jete 7, pasi array prind permban 3 elemente, array i brendshem me celes emrat permban 2 elemente, dhe array i brendshem me celes moshat permban 2 elemente. Ne total llogariten 7 elemente.

`array_diff`

array_diff(first_array, $array [, ...$array...])

Pranon si parametra ne hyrje dy ose me shume array. Te gjitha vlerat e array-ve te tjere krahasohen me vlerat ne array-n e pare first_array te dhene ne hyrje. Si output kthehet nje array i ri me te gjitha vlerat e first_array te cilat nuk ndodhen si vlera tek array-t e tjere.

Shembull:

$array1 = array( 'nje', 'dy', 'tre', 'kater' );
$array2 = array( 'dy', 'tre' );
$array3 = array( 'arber' => 'nje' );

$new_array = array_diff($array, $array2, $array3);

print_r( $new_array );

Rezultati:

Array ( [3] => kater )

Shohim qe ne dalje kthehet nje array me vetem nje element me vlere kater. $array1 permban kater vlera 'nje', 'dy', 'tre', 'kater'. Nga keto kater vlera, 'dy', 'tre' gjenden ne arrayn e dyte $array2 ndaj perjashtohen ne output. Array i trete $array3 ka element me celes associative 'arber' => 'nje' me celes arber, por vlere nje. Ajo krahasohet me array-n e pare eshte vlera dhe jo celesi, ndaj edhe vlera nje perjashtohet ne output. I vetmi element qe mbetet eshte elementi me vlere kater, i cili a indeks [3] pasi eshte elementi i katert ne $array1.

array_diff_key() – kryen te njejtin funksion por bazohet ne celesat dhe jo ne vlerat e array-ve.
array_diff_assoc() - kryen te njejtin funksion por bazohet ne vlerat dhe ne celesat array-ve, te dyja sebashku.
array_intersect() - Ne ndryshim nga funksionet e mesiperme, kthen nje array te ri me elementet qe jane prezent ne te gjitha array-t ne hyrje.

Shembuj:

$array1 = array( 'zero', 'emri' => 'arber', 'pseudonimi' => 'arbi' );
$array2 = array( 'tre', 'pseudonimi' => 'arber' );

$new_array = array_diff_key($array1, $array2);

print_r( $new_array );

Rezultati:

Array ( [emri] => arber )

$array1 = array( 'zero', 'nje', 'emri' => 'arber' );
$array2 = array( 'zero', 'tre', 'emri' => 'arber' );
print_r( array_diff_assoc($array1, $array2) );

Rezultati:

Array ( [1] => nje )

$array1 = array( 'nje', 'dy');
$array2 = array( 'dy', 'nje', 'tre', 'kater' );
$array3 = array( 'arber' => 'nje' );

//Shohim qe vetem vlera 'nje' gjendet tek te treja array-t

print_r( array_intersect($array1, $array2, $array3) );

Rezultati:

Array ( [0] => nje )

`array_flip`

array_flip($array)

Merr ne hyrje nje array dhe kthen nje array te ri i cili ka si vlera, celesat e array-t hyres, dhe ka si celesa , clerat e array-t hyres. Pra, be nje konvertim te celesave ne vlera, dhe anasjelltas.

Shembull:

$array = array( 'CEO' => 'Alban', 'Pronar' => 'Arber' );

$new_array = array_flip($array);

print_r( $new_array );

Rezultati:

Array
(
  [Alban] => CEO
  [Arber] => Pronar
)

`array_reverse`

array_reverse ( array $array [, bool $preserve_keys = false ] )

Merr ne hyrje nje array dhe kthen nje array te ri me renditjen e elementeve ne te kundert. Nqs. parametri opsional preserve_keys vendoset TRUE, atehere celesat numerik ruhen, pavaresisht ndryshimit te renditjes.

Shembull:

$input  = array("php", 4, array("green", "red"));

$reversed = array_reverse($input);

print_r($reversed);

Rezultati:

Array
(
    [0] => Array
        (
            [0] => green
            [1] => red
        )

    [1] => 4
    [2] => php
)

Ne rastin kur kalojme parametrin e dyte TRUE:

$input  = array("php", 4, array("green", "red"));

$preserved = array_reverse($input, TRUE);

print_r($preserved);

Pavaresisht ndryshimit te renditjes, indekset numerike ruhen sipas elementit qe kishin me pare:

Array
(
    [2] => Array
        (
            [0] => green
            [1] => red
        )

    [1] => 4
    [0] => php
)

`array_key_exists`

array_key_exists ( $key , $array )

Funksioni kthen TRUE ne rast se celesi i dhene eshte vendosur ne $array. Celesi mund te jete cfaredo lloj vlere e mundshme per nje indeks ne array.

Shembull:

$search_array = array('ckemi' => 1, 'pershendetje' => 2);

if (array_key_exists('ckemi', $search_array)) {
    echo "Celesi 'ckemi' gjendet ne array.";
}

Rezultati: Celesi 'ckemi' gjendet ne array.

Pra, ne kushtin if behet kontrolli nqs. celesi ckemi gjendet ne array i vendosur apo jo. Dukeqenese ai eshte vendosur, funksioni kthen TRUE ndaj ekzekutohet blloku i kodit brenda kushtit if.

`array_search`

array_search ( $needle , array $haystack [, bool $strict = false ] )

Kontrollohet nqs. $needle (mund te jete string, integer apo dicka tjeter) gjendet ne array-n $haystack. Ne rast se po atehere kthehet celesi perkates i array-t per elementin e gjetur ne rastisjen e tij te pare. Ne rast se nuk gjendet kthehet FALSE. Nqs. $needle eshte nje string, krahasimi behet case-sensitive. Ne rast se parametrin e trete opsional $strict e vendosim TRUE atehere kerkimi behet me strikt si p.sh. stringa '1' nuk konsiderohet e barabarte me numrin 1.

Shembull:

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');

$key = array_search('green', $array);   // $key = 2;
echo $key;

Rezultati: 2

$key = array_search('red', $array);   // $key = 1;
echo $key;

Rezultati: 1

`in_array`

in_array ( $needle , array $haystack [, bool $strict = FALSE ] )

Kontrollon nqs. nje vlere $needle gjendet ne array $haystack. Kthen TRUE nqs. vlera gjendet, perndryshe kthen FALSE. Nqs. $needle eshte nje string, krahasimi behet case-sensitive Ne rast se parametrin e trete opsional $strict e vendosim TRUE, atehere kontrolli behet me strikt si p.sh. stringa '1' nuk konsiderohet e barabarte me numrin 1.

Shembull:

$os = array("Linux", "Windows", "Mac");

if (in_array("Linux", $os)) {
    echo "Gjendet Linux";
}

Rezultati ne dalje do te jete Gjendet Linux, sepse vlera Linux eshte e pranishme ne array-n $os.

if (in_array("mac", $os)) {
    echo "Gjendet mac";
}

Me lart nuk do te printohet asgje pasi vlera mac nuk gjendet ne array-n $os. Parashtruam qe ne rastin e stringave kerkimi behet case-sensitive, keshtu qe vlera Mac (e cila gjendet ne array) nuk eshte e njejte me vleren mac.

`array_pop`

array_pop ( array &$array )

Kthen elementin e fundit te array-t ne hyrje, si dhe ndryshon madhesine e array-t ne hyrje duke e shkurtuar, me elementin e fundit te fshire. Parametri ne hyrje kalon me reference, ndaj duhet te dime qe ndryshimi behet mbi array-n origjinal, dhe jo kopje e tij.

Shembull:

$stack = array("portokall", "banane", "molle", "luleshtrydhe");

$frut = array_pop($stack);

print_r($stack);

Rezultati ne dalje do te jete array me nje element te hequr:

Array
(
    [0] => portokall
    [1] => banane
    [2] => molle
)

Ne rast se do te printojme vleren e kthyer nga funksioni:

echo $frut;

Rezultati: luleshtrydhe

`array_push`

int array_push ( array &$array , mixed $value1 [, mixed $... ] )

Shton nje ose me shume elemente ne fundin e array-t te dhene ne hyrje. Array ne hyrje futet me reference, ndaj ndryshimi do te behet mbi te. Funksioni kthen numrin e ri te elementeve te array-t te ndertuar. Funksioni i mesiperm ka te njejtin efekte me deklaraten:

$array[] = "vlere e dhene";

Pra, ashtu si kjo deklarate shton nje element ne fund te array-t $array, ashtu mund te shtohet edhe me funksionin array_push:

array_push($array, "vlere e dhene");

Shembull:

$stack = array("portokall", "banane");

array_push($stack, "molle", "luleshtrydhe");

print_r($stack);

Rezultati:

Array
(
    [0] => portokall
    [1] => banane
    [2] => molle
    [3] => luleshtrydhe
)

`array_shift`

array_shift ( array &$array )

Zhvendos (heq) elementin e pare te array-t dhe e kthen ate. Edhe ne kete rast array ne hyrje kalohet me reference. Ne rast se array eshte i perbere nga indekse numerike, nqs. elementi qe hiqet eshte me indeks numerik, atehere indekset numerike ne array do te modifikohen qe te nisin nga zero, ndersa celesat jo numerike nuk do te preken.

Ne rast se parametri ne hyrje eshte array bosh, ose nuk eshte array atehere funksioni do te ktheje NULL.

Shembull:

$stack = array("portokall", "banane", "molle", "luleshtrydhe");

$frut = array_shift($stack);

print_r($stack);

Rezultati:

Array
(
    [0] => banane
    [1] => molle
    [2] => luleshtrydhe
)

echo $frut;

Rezultati: portokall

`array_unshift`

array_unshift ( array &$array , mixed $value1 [, mixed $... ] )

Shton nje ose me shume elemente ne fillim te array-t. Elementet e shtuara do te mbajne te njejten renditje ne array ashtu sic renditen kur jepen si parametra ne funksion. Indekset numerike ne array do te modifikohen qe te nisin nga zero, ndersa celesat jo numerike nuk do te preken. Funksioni kthen numrin e elementeve te array-t te ri te ndertuar.

Shembull:

$queue = array("portokall", "banane");

array_unshift($queue, "molle", "luleshtrydhe");

print_r($queue);

Rezultati:

Array
(
    [0] => molle
    [1] => luleshtrydhe
    [2] => portokall
    [3] => banane
)

`sort`

sort(array $array [, sort_flag])

sort_flag – [opsional] default: SORT_REGULAR (krahason elementet normalisht)
                                SORT_NUMERIC (krahason elementet numerikisht)
                                SORT_STRING (krahason elementet si stringa)
                                etj...

Funksioni radhit elementet e nje array nga me i vogli tek me i madhi dhe riindekson (rivendos indekset) te gjitha vlerat, duke i shkaterruar elementet celesat aktual. Ne rast se parametri i dyte opsional nuk kalohet behet nje krahasim normal i elementeve, perndryshe behet krahasimi ne varesi te vleres se tij si krahasim numerik, krahasim si stringe etj.

Shembull:

$frute = array("limon", "portokall", "banane", "molle");

sort($frute);

foreach ($frute as $key => $val) {
    echo "frute[" . $key . "] = " . $val . "\n";
}

Rezultati ne dalje i shfaq te radhitura ne menyre alfabetike:

frute[0] = banane
frute[1] = limon
frute[2] = molle
frute[3] = portokall

asort() – kryen te njejtin funksion vetem se celesat mbahen (nuk rivendosen)
ksort() - kryen te njejtin funksion vetem se radhit celesat dhe jo vlerat
rsort() - ka te njejtin funksion vetem se behet radhitja nga me i madhi tek me i vogli.

Funksione te koleksioneve Array